package com.shundr.shipper.common.util;

import java.util.Timer;
import java.util.TimerTask;

import android.content.Context;
import android.media.AudioManager;
import android.media.SoundPool;
import android.os.Bundle;
import android.os.CountDownTimer;
import android.util.Log;

import com.iflytek.cloud.ErrorCode;
import com.iflytek.cloud.InitListener;
import com.iflytek.cloud.SpeechConstant;
import com.iflytek.cloud.SpeechError;
import com.iflytek.cloud.SpeechSynthesizer;
import com.iflytek.cloud.SpeechUtility;
import com.iflytek.cloud.SynthesizerListener;
import com.iflytek.cloud.util.ResourceUtil;
import com.iflytek.cloud.util.ResourceUtil.RESOURCE_TYPE;
import com.shundr.shipper.R;
import com.shundr.shipper.frame.constant.LContext;

/**
 * 语音播报工具类
 * TtsTools
 * 
 * @author larry 2015-4-24 下午4:56:08 
 * @version 1.0.0
 *
 */
public class TtsTools {
	private String voicerCloud = "xiaoyan";
	private static final String TAG = "TtsTools";
	private SpeechSynthesizer mTts;
 
	private String voicerLocal = "xiaoyan";
	private Context mContext;
	private boolean isSpeaking = false;
	public static long  Interval=10*1000;
	
	private SoundPool mSoundPool;
	private AudioManager mAudioManager;
 
	public TtsTools(Context context) {
		mContext = context;
		StringBuffer param = new StringBuffer();
		param.append("appid=5552f5af");
		param.append(",");
		// 设置使用v5+
		// mTts.setParameter(SpeechConstant.APPID, "52d91ab9");
		param.append(SpeechConstant.ENGINE_MODE + "=" + SpeechConstant.MODE_MSC);
		try {
			SpeechUtility.createUtility(context, param.toString());
		} catch (Exception e) {
			Log.e(TAG, "找不到文件路径");
		}
		// 1.创建SpeechSynthesizer对象
		mTts = SpeechSynthesizer.createSynthesizer(context, mTtsInitListener);
		if(mTts != null){
			initialize(false);
		}
		if(mSoundPool == null){
//			mSoundPool= new SoundPool(10,AudioManager.STREAM_SYSTEM,5);
			mSoundPool = new SoundPool(1, AudioManager.STREAM_MUSIC, 0);
			mSoundPool.load(mContext,R.raw.cargo,1);
		}
	}

	/**
	 * 停止播放语音
	 * stop(这里用一句话描述这个方法的作用)
	 * (这里描述这个方法适用条件 – 可选)
	 * void
	 * @exception
	 * @since  1.0.0
	 */
	public void stop() {
//  如果正在播放语音，并且 设置禁用语音，则关闭当前正在播放的语音
		if (mTts != null && mTts.isSpeaking()) {
			mTts.stopSpeaking();
			isSpeaking = false;
		}
	}
	
	/**
	 * 暂停语音
	 * pause(这里用一句话描述这个方法的作用)
	 * (这里描述这个方法适用条件 – 可选)
	 * void
	 * @exception
	 * @since  1.0.0
	 */
	public void pause() {
// 如果正在播放语音，并且 设置暂停语音，则关闭当前正在播放的语音
		if (mTts != null && mTts.isSpeaking()) {
			mTts.pauseSpeaking();
			isSpeaking = false;
		}
	}

	/**
	 * 计时器 实现 语音播放后 间隔 Interval 时间，再次播放
	 */
	private CountDownTimer mCountDownTimer = new CountDownTimer(Interval, 1000) {

		@Override
		public void onTick(long millisUntilFinished) {}

		@Override
		public void onFinish() {
			Log.i(TAG, "on CountDownTimer on finish");
			isSpeaking = true;
		}
	};
 	
	
	/**
	 * 初始化监听。
	 */
	private InitListener mTtsInitListener = new InitListener() {
		@Override
		public void onInit(int code) {
			Log.d(TAG, "InitListener init() code = " + code);
			if (code != ErrorCode.SUCCESS) {
				Log.e(TAG, "初始化失败,错误码：" + code);
			}
		}
	};

	/**
	 * 将文本类容转化为声音并播放
	 * 
	 * @param text
	 *            文本内容
	 * @return true表示转化成功，false 转化失败
	 */
	public void speak(final String text) {
		if(mTts == null){
			return;
		}	
		if(mTts.isSpeaking()){
			return;
		}
		if(mSoundPool != null){
			mSoundPool.play(1, 1, 1, 0, 0, 1);
		}
		new Timer().schedule(new TimerTask() {
			
			@Override
			public void run() {
				int result = mTts.startSpeaking(text, mTtsListener);
				Log.e(TAG, "start to speak "+text + " : " + result);
				if (result == ErrorCode.SUCCESS){
					isSpeaking = true;
				}
			}
		}, 500);
		
	}
	
	private int getVolume(Context context){  
    	int volume = -1;          
    	mAudioManager = (AudioManager)context.getSystemService(Context.AUDIO_SERVICE);  
    	volume = mAudioManager.getStreamVolume(AudioManager.STREAM_SYSTEM);  
    	Log.i("STREAM_RING", ""+volume);
    	return volume;      
    }   
	
	/**
	 * 复位
	 * resume(这里用一句话描述这个方法的作用)
	 * (这里描述这个方法适用条件 – 可选)
	 * void
	 * @exception
	 * @since  1.0.0
	 */
	public void resume() {
		if (mTts == null)
			return;
		if (!mTts.isSpeaking()) {
			mTts.resumeSpeaking();
		}
		Log.i(TAG, "the tts is   started,cannot resume it");
	}

	/**
	 * 用户重新登录后，调用此初始化函数
	 * 参数设置
	 * 
	 * @param param true 表示使用本地语音引擎，false表示使用在线语音合成
	 * @return
	 */
	public void initialize(boolean isLocal) {
		// 清空参数
		mTts.setParameter(SpeechConstant.PARAMS, null);
		// 设置合成
		if (!isLocal) {
			// 设置使用云端引擎
			mTts.setParameter(SpeechConstant.ENGINE_TYPE, SpeechConstant.TYPE_CLOUD);
			// 设置发音人
			mTts.setParameter(SpeechConstant.VOICE_NAME, voicerCloud);
		} else {
			// 设置使用本地引擎
			mTts.setParameter(SpeechConstant.ENGINE_TYPE, SpeechConstant.TYPE_LOCAL);
			// 设置发音人资源路径
			mTts.setParameter(ResourceUtil.TTS_RES_PATH, getResourcePath());
			// 设置发音人
			mTts.setParameter(SpeechConstant.VOICE_NAME, voicerLocal);
		}

		/**
		 * 设置默认属性
		 */
		mTts.setParameter(SpeechConstant.APPID, "52d91ab9");
		// 设置语速
		mTts.setParameter(SpeechConstant.SPEED, "60");
		// 设置音调
		mTts.setParameter(SpeechConstant.PITCH,"50");
		// 设置音量
		mTts.setParameter(SpeechConstant.VOLUME,"100");
		// 设置播放器音频流类型
		mTts.setParameter(SpeechConstant.STREAM_TYPE,"3");
	}

	// 获取发音人资源路径
	private String getResourcePath() {
		StringBuffer tempBuffer = new StringBuffer();
		// 合成通用资源
		tempBuffer.append(ResourceUtil.generateResourcePath(mContext,
				RESOURCE_TYPE.assets, "tts/common.jet"));
		tempBuffer.append(";");
		// 发音人资源
		tempBuffer.append(ResourceUtil.generateResourcePath(mContext,
				RESOURCE_TYPE.assets, "tts/" + voicerLocal + ".jet"));
		return tempBuffer.toString();
	}

	/**
	 * 合成播发回调接口。
	 */
	public SynthesizerListener mTtsListener = new SynthesizerListener() {
		@Override
		public void onSpeakBegin() {
			Log.e(TAG, "开始播放");
		}

		@Override
		public void onSpeakPaused() {
			Log.e(TAG, "暂停播放");
		}

		@Override
		public void onSpeakResumed() {
			Log.e(TAG, "继续播放");
		}

		@Override
		public void onBufferProgress(int percent, int beginPos, int endPos,
				String info) {
		}

		@Override
		public void onSpeakProgress(int percent, int beginPos, int endPos) {
		}

		@Override
		public void onCompleted(SpeechError error) {
			//启动计时器
			mCountDownTimer.start();
			if (error == null) {
				Log.e(TAG, "播放完成");
			} else if (error != null) {
				Log.e(TAG, error.getPlainDescription(true));
			}
		}

		@Override
		public void onEvent(int arg0, int arg1, int arg2, Bundle arg3) {
		}
	};

	/**
	 * 关闭语音合成引擎
	 */
	public void release() {
		if (mTts == null) {
			Log.i(TAG, "the mTts is null release fail");
			return;
		}
		if (mTts.isSpeaking()) {
			mTts.stopSpeaking();
		}
		// 退出时释放连接
		mTts.destroy();
	}
	
	/**
	 * 禁用TTS
	 */
	public void disableTTS(){
		LContext.isTtsOpened = false;
		stop();
		PrefUtils.setPrefBoolean(mContext, PrefConstants.IS_TTS_ON, false);
	}
	/**
	 *启用TTS 
	 */
	public void enableTTS(){
		LContext.isTtsOpened = true;
		PrefUtils.setPrefBoolean(mContext, PrefConstants.IS_TTS_ON, true);
	}
}
